unit u_load;

interface

uses
  sysutils;

type

    t_contenu = record
      nom: string;
      _type: string;
      carac1: integer;
      carac2: integer;
      quantite: integer;
      equip: boolean;
      mesh: string;
      icone: string;
      g_d: char;
    end;

    t_tab_cont = array of t_contenu;

    objet_map = record
      rotation : integer;//la rotation pour le jeu...
      x,y : integer;//taille sur la map en nombre de case
      mesh : string;
      _type : string;
      nom : string;
      numobj : integer;//trés important pour lier les objets entre eux!!
      taille : integer;//Ram
      capacite : integer;//disque dur
      puissance : integer;//Carte graphique
      vitesse : integer;//Processeur
      portee : integer;//Armes
      degat : integer;//Armes et piege
      quantite : integer;//Argent
      etage : integer;//Ascenceur
      text : string;//Livre
      script : string;//Gentil petit asus ou boss
      niveau : integer;//[1..100] tous types ennemis ou boss
      contenu : t_contenu;//objet à la mort de l'ennemi ou coffre ou boss
      //ouvert : boolean pour le jeu pour savoir si la porte est ouverte ou fermée.
  end;

  T_Map = Array of Array of Array of objet_map;

  t_coordo = record
    x: integer;
    y: integer;
    num: integer;
  end;

  t_object = record
    objet : objet_map;
    tab_etage : array of t_coordo;
  end;

  T_eta_obj = array of t_object;

  t_map_obj = array of T_eta_obj;

function load_map( var map : T_map;
                   var taillex : integer;
                   var tailley : integer;
                   var nbretage : integer;
                   var nbrobj : integer;
                   var dep_etage : integer;
                   var dep_x: integer;
                   var dep_y: integer;
                   path : string;
                   game_type: char ): boolean;

function tri_map(map: t_map;
                 taillex: integer;
                 tailley: integer;
                 nbetage: integer;
                 dep_etage: integer;
                 nbrobj: integer): t_map_obj;

function tri_etage_stat(map: T_Map;
                        etage: integer;
                        taillex: integer;
                        tailley: integer;
                        nbrobj: integer): T_eta_obj;

procedure save_map(f_name : string);

procedure load_save(f_name : string);


implementation

uses u_mesh,
     u_engine;

function load_map( var map : T_map;
                   var taillex : integer;
                   var tailley : integer;
                   var nbretage : integer;
                   var nbrobj : integer;
                   var dep_etage : integer;
                   var dep_x: integer;
                   var dep_y: integer;
                   path : string;
                   game_type : char ): boolean;
var
  fichier : TextFile;
  buf : string;
  i, j, k : integer;
  begin
    try
      AssignFile(fichier, path);
      Reset(fichier);
      Readln(fichier, buf);
      taillex := StrToInt(buf);
      Readln(fichier, buf);
      tailley := StrToInt(buf);
      Readln(fichier, buf);
      nbretage := StrToInt(buf);
      Readln(fichier, buf);
      nbrobj := StrToInt(buf);
      SetLength(map, nbretage + 1, taillex, tailley);
      for k := 0 to nbretage do
       for i := 0 to taillex - 1 do
        for j := 0 to tailley - 1 do

            begin
              Readln(fichier, buf);
              if buf = 'Depart' then
                begin
                  dep_etage := k;
                  dep_x := j;
                  dep_y := i;
//                  myplayer.player_goto(j, i);
                end;
              map[k, i, j]._type := buf;

              if buf <> 'none' then
                begin
                  Readln(fichier, buf);
                  map[k, i, j].nom := buf;
                  Readln(fichier, buf);
                  map[k, i, j].numobj := StrToInt(buf);
                  Readln(fichier, buf);
                  map[k, i, j].mesh := buf;
                  Readln(fichier, buf);
                  map[k, i, j].x := StrToInt(buf);
                  Readln(fichier, buf);
                  map[k, i, j].y := StrToInt(buf);
                  if map[k, i, j]._type = 'Argent' then
                    begin
                      Readln(fichier, buf);
                      map[k, i, j].quantite := StrToInt(buf);
                    end;
                  if map[k, i, j]._type = 'Armes' then
                    begin
                      Readln(fichier, buf);
                      map[k, i, j].portee := StrToInt(buf);
                      Readln(fichier, buf);
                      map[k, i, j].degat := StrToInt(buf);
                    end;
                  if map[k, i, j]._type = 'Ascenceur' then
                    begin
                      Readln(fichier, buf);
                      map[k, i, j].etage := StrToInt(buf);
                    end;
                  if map[k, i, j]._type = 'Boss' then
                    begin
                      Readln(fichier, buf);
                      map[k, i, j].contenu.nom := buf;
                      Readln(fichier, buf);
                      map[k, i, j].niveau := StrToInt(buf);
                      Readln(fichier, buf);
                      map[k, i, j].script := buf;
                    end;
                  if map[k, i, j]._type = 'Carte graphique' then
                    begin
                      Readln(fichier, buf);
                      map[k, i, j].puissance := StrToInt(buf);
                    end;
                  if map[k, i, j]._type = 'Coffre' then
                    begin
                      Readln(fichier, buf);
                      map[k, i, j].contenu.nom := buf;
                    end;
                  if map[k, i, j]._type = 'Disque dur' then
                    begin
                      Readln(fichier, buf);
                      map[k, i, j].capacite := StrToInt(buf);
                    end;
                  if (map[k, i, j]._type = 'Ennemi statique')
                     or (map[k, i, j]._type = 'Ennemi dynamique')
                     or (map[k, i, j]._type = 'Kamikaze')
                     or (map[k, i, j]._type = 'Espion') then                   //           /|
                     begin                                                    //           / /
                       Readln(fichier, buf);                                 //            / /
                       map[k, i, j].contenu._type := buf;                   //             / /
                       Readln(fichier, buf);                                            // /// //
                       map[k, i, j].contenu.nom := buf;                               // //  //  //
                       Readln(fichier, buf);                                           //      //
                       map[k, i, j].contenu.carac1 := StrToInt(buf);
                       Readln(fichier, buf);
                       if buf <> '' then
                         map[k, i, j].contenu.carac2 := StrToInt(buf);
                       Readln(fichier, buf);
                       map[k, i, j].contenu.mesh := buf;
                       Readln(fichier, buf);
                       map[k, i, j].niveau := StrToInt(buf);
                       if game_type = 'c' then
                         begin
                            map[k, i, j].nom := '';
                            map[k, i, j].mesh := '';
                            map[k, i, j]._type := 'none';
                         end;
                         buf := 'none';
                     end;
                  if map[k, i, j]._type = 'Gentil petit asus' then
                    begin
                      Readln(fichier, buf);
                      map[k, i, j].script := buf;
                    end;
                  if map[k, i, j]._type = 'Livre' then
                    begin
                      Readln(fichier, buf);
                      map[k, i, j].text := buf;
                    end;
                  if map[k, i, j]._type = 'Piege' then
                    begin
                      Readln(fichier, buf);
                      map[k, i, j].degat := StrToInt(buf);
                    end;
                  if map[k, i, j]._type = 'Processeur' then
                    begin
                      Readln(fichier, buf);
                      map[k, i, j].vitesse := StrToInt(buf);
                    end;
                  if map[k, i, j]._type = 'Ram' then
                    begin
                      Readln(fichier, buf);
                      map[k, i, j].taille := StrToInt(buf);
                    end;
                end;
              if map[k, i, j]._type = 'none' then
                map[k, i, j].nom := buf;
            end;
    except
      On E : Exception do
        begin
          Result := false;
          writeln('i : ', i);
          Writeln('j : ', j);
          Exit;
        end;
    end;
    Result := true;
end;

function tri_map(map: t_map;
                 taillex: integer;
                 tailley: integer;
                 nbetage: integer;
                 dep_etage: integer;
                 nbrobj: integer): t_map_obj;
var
  dep_et: integer;
  k, i, j: integer;
  nbeta : integer;
  temp : t_map_obj;
//  nb_dyn: integer;
begin

  k := 0;
  nbeta := 0;
  while k <= nbetage do
    begin
      nbeta := nbeta + 1;
      SetLength(temp, nbeta);
      temp[k] := tri_etage_stat(map, k, taillex, tailley,nbrobj);
      k := k + 1;
    end;
  result := temp;
end;



//
//
//
function tri_etage_stat(map: T_Map;
                        etage: integer;
                        taillex: integer;
                        tailley: integer;
                        nbrobj: integer): T_eta_obj;
var
  occ: integer;
  nb_total_obj: integer;
  nb_sort_obj: integer;
  i, j: integer;
  temp_sort_none, temp_sort_caca: integer;
  temp_eta: T_eta_obj;
  temp1, temp2: string;
  temp_none, temp_sol, temp_caca: integer;
  temp_caca_bool, temp_none_bool: boolean;
  temp_caca_bool2, temp_none_bool2: boolean;
  temp_coor: t_coordo;
  temp_1er_caca, temp_1er_none: boolean;
begin
  nb_total_obj := 0;
  nb_sort_obj := 0;
  temp2 := map[etage, 0, 0].nom;
  temp_caca_bool := false;
  temp_none_bool := false;
  temp_caca_bool2 := false;
  temp_none_bool2 := false;
  temp_1er_caca := true;
  temp_1er_none := true;
  while nb_total_obj < taillex * tailley do
    begin
      j := 0;
      temp1 := temp2;
      occ := 0;
      nb_sort_obj := nb_sort_obj + 1;
      if (temp1 = 'none') and (temp_none_bool2 = true) then
        begin

        end
      else
        if (temp1 = 'caca') and (temp_caca_bool2 = true) then
          begin

          end
        else
          SetLength(temp_eta, nb_sort_obj);
      while j < tailley do
        begin
          i := 0;
          while i < taillex  do
            begin
              if temp1 = map[etage, i ,j].nom then
                begin
                  occ := occ + 1;
                  SetLength(temp_eta[nb_sort_obj - 1].tab_etage, occ);
                  if (map[etage, i, j]._type = 'Ennemi statique') or
                     (map[etage, i, j]._type = 'Ennemi dynamique') or
                     (map[etage, i, j]._type = 'Kamikaze') or
                     (map[etage, i, j]._type = 'Espion') or
                     (map[etage, i, j]._type = 'Gentil petit asus') or
                     (map[etage, i, j]._type = 'Boss') or
                     (map[etage, i, j]._type = 'Argent') or
                     (map[etage, i, j]._type = 'Arrivee') or
                     (map[etage, i, j]._type = 'Depart')
                       then
                         begin
                      if (i > 0) and (map[etage, i - 1, j]._type = 'Sol') then
                        begin
                          temp_sol := 1;
                          temp_coor.x := i - 1;
                          temp_coor.y := j
                        end
                      else
                        if (i < taillex - 1) and (map[etage, i + 1, j]._Type = 'Sol') then
                          begin
                            temp_sol := 1;
                            temp_coor.x := i + 1;
                            temp_coor.y := j;
                          end
                        else
                          if (j < tailley - 1) and (map[etage, i, j + 1]._Type = 'Sol') then
                            begin
                              temp_sol := 1;
                              temp_coor.x := i;
                              temp_coor.y := j + 1;
                            end
                          else
                            if ( j > 0) and (map[etage, i, j - 1]._Type = 'Sol') then
                              begin
                                temp_sol := 1;
                                temp_coor.x := i;
                                temp_coor.y := j - 1;
                              end
                            else
                              if (i < taillex) and (map[etage, i + 1, j]._Type = 'none') then
                                begin
                                  temp_sol := 0;
                                  temp_coor.x := i + 1;
                                  temp_coor.y := j;
                                end
                              else
                                if ( i > 0) and (map[etage, i - 1, j]._Type = 'none') then
                                  begin
                                    temp_sol := 0;
                                    temp_coor.x := i - 1;
                                    temp_coor.y := j;
                                  end
                                else
                                  if (j < tailley) and (map[etage, i, j + 1]._Type = 'none') then
                                    begin
                                      temp_sol := 0;
                                      temp_coor.x := i;
                                      temp_coor.y := j + 1;
                                    end
                                  else
                                    if (j > 0) and (map[etage, i, j - 1]._Type = 'none') then
                                      begin
                                        temp_sol := 0;;
                                        temp_coor.x := i;;
                                        temp_coor.y := j - 1;
                                      end;
                    case temp_sol of
                      0: begin
                           if temp_1er_none then
                            begin
                              setlength(temp_eta, temp_sort_none + 1);
                              temp_eta[temp_sort_none].objet := map[etage, temp_coor.x, temp_coor.y];
                              temp_1er_none := false;
                            end;
                           temp_none_bool2 := true;
                           SetLength(temp_eta[temp_sort_none].tab_etage, temp_none + 1);
                           temp_eta[temp_sort_none].tab_etage[temp_none].x := i;
                           temp_eta[temp_sort_none].tab_etage[temp_none].y := j;
                           temp_none := temp_none + 1;
                         end;
                      1: begin
                           if temp_1er_caca then
                             begin
                               setlength(temp_eta, temp_sort_caca + 1);
                               temp_eta[temp_sort_caca].objet := map[etage, temp_coor.x, temp_coor.y];
                               temp_1er_caca := false;
                             end;
                           temp_caca_bool2 := true;
                           SetLength(temp_eta[temp_sort_caca].tab_etage, temp_caca + 1);
                           temp_eta[temp_sort_caca].tab_etage[temp_caca].x := i;
                           temp_eta[temp_sort_caca].tab_etage[temp_caca].y := j;
                           temp_caca := temp_caca + 1;
                         end;
                    end;
                    temp_eta[nb_sort_obj - 1].objet := map[etage, i, j];
                    temp_eta[nb_sort_obj - 1].tab_etage[occ - 1].x := i;
                    temp_eta[nb_sort_obj - 1].tab_etage[occ - 1].y := j;
                    temp_eta[nb_sort_obj - 1].tab_etage[occ - 1].num := map[etage, i, j].numobj;
                         end
                  else
                    begin
                      if temp1 = 'none' then
                        begin
                          temp_1er_none := false;
                          temp_none := temp_none + 1;
                          temp_sort_none := nb_sort_obj - 1;
                          temp_none_bool := true;
                        end
                      else
                        if (temp_none_bool = false) and (temp_none_bool2 = false) then
                          temp_sort_none := nb_sort_obj;
                      if temp1 = 'caca' then
                        begin
                          temp_1er_caca := false;
                          temp_caca := temp_caca + 1;
                          temp_sort_caca := nb_sort_obj - 1;
                          temp_caca_bool := true;
                        end
                      else
                        if (temp_caca_bool = false) and (temp_caca_bool2 = false) then
                          temp_sort_caca := nb_sort_obj;
                      if (temp1 = 'none') and (temp_none_bool2 = true) then
                        begin
                          temp_eta[temp_sort_none].objet := map[etage, i, j];
                          temp_eta[temp_sort_none].tab_etage[temp_none - 1].x := i;
                          temp_eta[temp_sort_none].tab_etage[temp_none - 1].y := j;
                          temp_eta[temp_sort_none].tab_etage[temp_none - 1].num := map[etage, i, j].numobj;
                        end
                      else
                        if (temp1 = 'caca') and (temp_caca_bool2 = true) then
                          begin
                            temp_eta[temp_sort_caca].objet := map[etage, i, j];
                            temp_eta[temp_sort_caca].tab_etage[temp_caca - 1].x := i;
                            temp_eta[temp_sort_caca].tab_etage[temp_caca - 1].y := j;
                            temp_eta[temp_sort_caca].tab_etage[temp_caca - 1].num := map[etage, i, j].numobj;
                          end
                        else
                          begin
                            temp_eta[nb_sort_obj - 1].objet := map[etage, i, j];
                            temp_eta[nb_sort_obj - 1].tab_etage[occ - 1].x := i;
                            temp_eta[nb_sort_obj - 1].tab_etage[occ - 1].y := j;
                            temp_eta[nb_sort_obj - 1].tab_etage[occ - 1].num := map[etage, i, j].numobj;
                          end;
                    end;
                  nb_total_obj := nb_total_obj + 1;
                  map[etage, i, j].nom := '';
                end
              else
                if map[etage, i ,j].nom <> '' then
                    temp2 := map[etage, i ,j].nom;
              i := i + 1;
            end;
          j := j + 1;
        end;
    end;
  result := temp_eta;
end;


procedure save_map(f_name : string);
var
  fichier : TextFile;
  i, j, k : integer;
  buf : string;
  temp_map : T_map;
  begin
    AssignFile(fichier, myplayer.map_name);
    Reset(fichier);

      Readln(fichier, buf);
      Readln(fichier, buf);
      Readln(fichier, buf);
      Readln(fichier, buf);

      SetLength(temp_map, mymesh.nbretage + 1, mymesh.taillex, mymesh.tailley);

      for k := 0 to mymesh.nbretage do
       for i := 0 to mymesh.taillex - 1 do
        for j := 0 to mymesh.tailley - 1 do
            begin
              Readln(fichier, buf);
              temp_map[k, i, j]._type := buf;
              if buf <> 'none' then
                begin
                  Readln(fichier, buf);
                  temp_map[k, i, j].nom := buf;
                  Readln(fichier, buf);
                  temp_map[k, i, j].numobj := StrToInt(buf);
                  Readln(fichier, buf);
                  temp_map[k, i, j].mesh := buf;
                  Readln(fichier, buf);
                  temp_map[k, i, j].x := StrToInt(buf);
                  Readln(fichier, buf);
                  temp_map[k, i, j].y := StrToInt(buf);
                  if temp_map[k, i, j]._type = 'Argent' then
                    begin
                      Readln(fichier, buf);
                      temp_map[k, i, j].quantite := StrToInt(buf);
                    end;
                  if temp_map[k, i, j]._type = 'Armes' then
                    begin
                      Readln(fichier, buf);
                      temp_map[k, i, j].portee := StrToInt(buf);
                      Readln(fichier, buf);
                      temp_map[k, i, j].degat := StrToInt(buf);
                    end;
                  if temp_map[k, i, j]._type = 'Ascenceur' then
                    begin
                      Readln(fichier, buf);
                      temp_map[k, i, j].etage := StrToInt(buf);
                    end;
                  if temp_map[k, i, j]._type = 'Boss' then
                    begin
                      Readln(fichier, buf);
                      temp_map[k, i, j].contenu.nom := buf;
                      Readln(fichier, buf);
                      temp_map[k, i, j].niveau := StrToInt(buf);
                      Readln(fichier, buf);
                      temp_map[k, i, j].script := buf;
                    end;
                  if temp_map[k, i, j]._type = 'Carte graphique' then
                    begin
                      Readln(fichier, buf);
                      temp_map[k, i, j].puissance := StrToInt(buf);
                    end;
                  if temp_map[k, i, j]._type = 'Coffre' then
                    begin
                      Readln(fichier, buf);
                      temp_map[k, i, j].contenu.nom := buf;
                    end;
                  if temp_map[k, i, j]._type = 'Disque dur' then
                    begin
                      Readln(fichier, buf);
                      temp_map[k, i, j].capacite := StrToInt(buf);
                    end;
                  if (temp_map[k, i, j]._type = 'Ennemi statique')
                     or (temp_map[k, i, j]._type = 'Ennemi dynamique')
                     or (temp_map[k, i, j]._type = 'Kamikaze')
                     or (temp_map[k, i, j]._type = 'Espion') then                   //           /|
                     begin                                                    //           / /
                       Readln(fichier, buf);                                 //            / /
                       temp_map[k, i, j].contenu._type := buf;                   //             / /
                       Readln(fichier, buf);                                            // /// //
                       temp_map[k, i, j].contenu.nom := buf;                               // //  //  //
                       Readln(fichier, buf);                                           //      //
                       temp_map[k, i, j].contenu.carac1 := StrToInt(buf);
                       Readln(fichier, buf);
                       if buf <> '' then
                         temp_map[k, i, j].contenu.carac2 := StrToInt(buf);
                       Readln(fichier, buf);
                       temp_map[k, i, j].contenu.mesh := buf;
                       Readln(fichier, buf);
                       temp_map[k, i, j].niveau := StrToInt(buf);
                       buf := 'none';
                     end;
                  if temp_map[k, i, j]._type = 'Gentil petit asus' then
                    begin
                      Readln(fichier, buf);
                      temp_map[k, i, j].script := buf;
                    end;
                  if temp_map[k, i, j]._type = 'Livre' then
                    begin
                      Readln(fichier, buf);
                      temp_map[k, i, j].text := buf;
                    end;
                  if temp_map[k, i, j]._type = 'Piege' then
                    begin
                      Readln(fichier, buf);
                      temp_map[k, i, j].degat := StrToInt(buf);
                    end;
                  if temp_map[k, i, j]._type = 'Processeur' then
                    begin
                      Readln(fichier, buf);
                      temp_map[k, i, j].vitesse := StrToInt(buf);
                    end;
                  if temp_map[k, i, j]._type = 'Ram' then
                    begin
                      Readln(fichier, buf);
                      temp_map[k, i, j].taille := StrToInt(buf);
                    end;
                end;
              if temp_map[k, i, j]._type = 'none' then
                temp_map[k, i, j].nom := buf;
            end;

      CloseFile(fichier);

    temp_map[mymesh.dep_eta.etage, mymesh.dep_eta.x, mymesh.dep_eta.y]._type := 'none';
    temp_map[mymesh.dep_eta.etage, mymesh.dep_eta.x, mymesh.dep_eta.y].nom := 'none';
    
    temp_map[myplayer.etage, myplayer.get_x, myplayer.get_y]._type := 'Depart';
    temp_map[myplayer.etage, myplayer.get_x, myplayer.get_y].nom := 'Depart';
    temp_map[myplayer.etage, myplayer.get_x, myplayer.get_y].mesh := 'meshes\arr.x';
    temp_map[myplayer.etage, myplayer.get_x, myplayer.get_y].x := 0;
    temp_map[myplayer.etage, myplayer.get_x, myplayer.get_y].y := 0;
    temp_map[myplayer.etage, myplayer.get_x, myplayer.get_y].numobj := temp_map[mymesh.dep_eta.etage, mymesh.dep_eta.x, mymesh.dep_eta.y].numobj;

    AssignFile(fichier, f_name + '.map');

    Rewrite(fichier);

    Writeln(fichier, IntToStr(mymesh.taillex));
    Writeln(fichier, IntToStr(mymesh.tailley));
    Writeln(fichier, IntToStr(mymesh.nbretage));
    Writeln(fichier, IntToStr(mymesh.nbrobj + 1));

  for k := 0 to mymesh.nbretage do
  for i := 0 to mymesh.taillex - 1 do
    for j := 0 to mymesh.tailley - 1 do
      begin
        Writeln(fichier, temp_map[k, i, j]._type);
        if temp_map[k, i, j]._type <> 'none' then
          begin
            Writeln(fichier, temp_map[k, i, j].nom);
            Writeln(fichier, temp_map[k, i, j].numobj);
            Writeln(fichier, temp_map[k, i, j].mesh);
            Writeln(fichier, temp_map[k, i, j].x);
            Writeln(fichier, temp_map[k, i, j].y);
            if temp_map[k, i, j]._type = 'Argent' then
              Writeln(fichier, temp_map[k, i, j].quantite);
            if temp_map[k, i, j]._type = 'Armes' then
              begin
                Writeln(fichier, temp_map[k, i, j].portee);
                Writeln(fichier, temp_map[k, i, j].degat);
              end;
            if temp_map[k, i, j]._type = 'Ascenceur' then
              Writeln(fichier, temp_map[k, i, j].etage);
            if temp_map[k, i, j]._type = 'Boss' then
              begin
                Writeln(fichier, temp_map[k, i, j].contenu._type);
                Writeln(fichier, temp_map[k, i, j].contenu.nom);
                Writeln(fichier, temp_map[k, i, j].contenu.carac1);
                Writeln(fichier, temp_map[k, i, j].contenu.carac2);
                Writeln(fichier, temp_map[k, i, j].contenu.mesh);
                Writeln(fichier, temp_map[k, i, j].niveau);
                Writeln(fichier, temp_map[k, i, j].script);
              end;
            if temp_map[k, i, j]._type = 'Carte graphique' then
              Writeln(fichier, temp_map[k, i, j].puissance);
            if temp_map[k, i, j]._type = 'Coffre' then
              begin
                Writeln(fichier, temp_map[k, i, j].contenu._type);
                Writeln(fichier, temp_map[k, i, j].contenu.nom);
                Writeln(fichier, temp_map[k, i, j].contenu.carac1);
                Writeln(fichier, temp_map[k, i, j].contenu.carac2);
                Writeln(fichier, temp_map[k, i, j].contenu.mesh);
              end;
            if temp_map[k, i, j]._type = 'Disque dur' then
              Writeln(fichier, temp_map[k, i, j].capacite);
            if (temp_map[k, i, j]._type = 'Ennemi statique')
               or (temp_map[k, i, j]._type = 'Ennemi dynamique')
               or (temp_map[k, i, j]._type = 'Kamikaze')
               or (temp_map[k, i, j]._type = 'Espion') then
               begin
                 Writeln(fichier, temp_map[k, i, j].contenu._type);
                 Writeln(fichier, temp_map[k, i, j].contenu.nom);
                 Writeln(fichier, temp_map[k, i, j].contenu.carac1);
                 Writeln(fichier, temp_map[k, i, j].contenu.carac2);
                 Writeln(fichier, temp_map[k, i, j].contenu.mesh);
                 Writeln(fichier, temp_map[k, i, j].niveau);
               end;
            if temp_map[k, i, j]._type = 'Gentil petit asus' then
              Writeln(fichier, temp_map[k, i, j].script);
            if temp_map[k, i, j]._type = 'Livre' then
              Writeln(fichier, temp_map[k, i, j].text);
            if temp_map[k, i, j]._type = 'Piege' then
              Writeln(fichier, temp_map[k, i, j].degat);
            if temp_map[k, i, j]._type = 'Processeur' then
              Writeln(fichier, temp_map[k, i, j].vitesse);
            if temp_map[k, i, j]._type = 'Ram' then
              Writeln(fichier, temp_map[k, i, j].taille);
          end;
      end;

      closefile(fichier);

    Assign(fichier, f_name + '.cladpute');
    rewrite(fichier);
    //on met les caractéristiques du joueur
    Writeln(fichier, inttostr(myplayer.carac.niveau.init));
    Writeln(fichier, inttostr(myplayer.carac.niveau.stuff));
    Writeln(fichier, inttostr(myplayer.carac.niveau.actuel));
    Writeln(fichier, inttostr(myplayer.carac.niveau.emplacement_libre));
    Writeln(fichier, inttostr(myplayer.carac.vie.init));
    Writeln(fichier, inttostr(myplayer.carac.vie.stuff));
    Writeln(fichier, inttostr(myplayer.carac.vie.actuel));
    Writeln(fichier, inttostr(myplayer.carac.vie.emplacement_libre));
    Writeln(fichier, inttostr(myplayer.carac.xp.init));
    Writeln(fichier, inttostr(myplayer.carac.xp.stuff));
    Writeln(fichier, inttostr(myplayer.carac.xp.actuel));
    Writeln(fichier, inttostr(myplayer.carac.xp.emplacement_libre));
    Writeln(fichier, inttostr(myplayer.carac.force.init));
    Writeln(fichier, inttostr(myplayer.carac.force.stuff));
    Writeln(fichier, inttostr(myplayer.carac.force.actuel));
    Writeln(fichier, inttostr(myplayer.carac.force.emplacement_libre));
    Writeln(fichier, inttostr(myplayer.carac.discretion.init));
    Writeln(fichier, inttostr(myplayer.carac.discretion.stuff));
    Writeln(fichier, inttostr(myplayer.carac.discretion.actuel));
    Writeln(fichier, inttostr(myplayer.carac.discretion.emplacement_libre));
    Writeln(fichier, inttostr(myplayer.carac.degats.init));
    Writeln(fichier, inttostr(myplayer.carac.degats.stuff));
    Writeln(fichier, inttostr(myplayer.carac.degats.actuel));
    Writeln(fichier, inttostr(myplayer.carac.degats.emplacement_libre));
    Writeln(fichier, inttostr(myplayer.carac.portee.init));
    Writeln(fichier, inttostr(myplayer.carac.portee.stuff));
    Writeln(fichier, inttostr(myplayer.carac.portee.actuel));
    Writeln(fichier, inttostr(myplayer.carac.portee.emplacement_libre));
    Writeln(fichier, inttostr(myplayer.carac.armure.init));
    Writeln(fichier, inttostr(myplayer.carac.armure.stuff));
    Writeln(fichier, inttostr(myplayer.carac.armure.actuel));
    Writeln(fichier, inttostr(myplayer.carac.armure.emplacement_libre));
    Writeln(fichier, inttostr(myplayer.carac.vitesse.init));
    Writeln(fichier, inttostr(myplayer.carac.vitesse.stuff));
    Writeln(fichier, inttostr(myplayer.carac.vitesse.actuel));
    Writeln(fichier, inttostr(myplayer.carac.vitesse.emplacement_libre));
    Writeln(fichier, inttostr(myplayer.carac.taille.init));
    Writeln(fichier, inttostr(myplayer.carac.taille.stuff));
    Writeln(fichier, inttostr(myplayer.carac.taille.actuel));
    Writeln(fichier, inttostr(myplayer.carac.taille.emplacement_libre));

    //maintenant les objts qu'il a sur lui
    Writeln(fichier, inttostr(Length(myplayer.tab_contenu)));
    if Length(myplayer.tab_contenu) <> 0 then
      for i := 0 to Length(myplayer.tab_contenu) - 1 do
        begin
          Writeln(fichier, myplayer.tab_contenu[i].nom);
          Writeln(fichier, myplayer.tab_contenu[i]._type);
          Writeln(fichier, IntToStr(myplayer.tab_contenu[i].carac1));
          Writeln(fichier, IntToStr(myplayer.tab_contenu[i].carac2));
          Writeln(fichier, IntToStr(myplayer.tab_contenu[i].quantite));
          Writeln(fichier, BoolToStr(myplayer.tab_contenu[i].equip));
          Writeln(fichier, myplayer.tab_contenu[i].mesh);
          Writeln(fichier, myplayer.tab_contenu[i].icone);
          Writeln(fichier, myplayer.tab_contenu[i].g_d);
        end;
    CloseFile(fichier);
  end;

procedure load_save(f_name : string);
var
  fichier : textfile;
  i, len : integer;
  buf : string;
  begin
    Assign(fichier, f_name + '.cladpute');
    reset(fichier);
    //on met les caractéristiques du joueur
    Readln(fichier, buf);
    myplayer.carac.niveau.init := StrToInt(buf);
    Readln(fichier, buf);
    myplayer.carac.niveau.stuff := strtoint(buf);
    Readln(fichier, buf);
    myplayer.carac.niveau.actuel := strtoint(buf);
    Readln(fichier, buf);
    myplayer.carac.niveau.emplacement_libre := strtoint(buf);
    Readln(fichier, buf);
    myplayer.carac.vie.init := strtoint(buf);
    Readln(fichier, buf);
    myplayer.carac.vie.stuff := strtoint(buf);
    Readln(fichier, buf);
    myplayer.carac.vie.actuel := strtoint(buf);
    Readln(fichier, buf);
    myplayer.carac.vie.emplacement_libre := strtoint(buf);
    Readln(fichier, buf);
    myplayer.carac.xp.init := strtoint(buf);
    Readln(fichier, buf);
    myplayer.carac.xp.stuff := strtoint(buf);
    Readln(fichier, buf);
    myplayer.carac.xp.actuel := strtoint(buf);
    Readln(fichier, buf);
    myplayer.carac.xp.emplacement_libre := strtoint(buf);
    Readln(fichier, buf);
    myplayer.carac.force.init := strtoint(buf);
    Readln(fichier, buf);
    myplayer.carac.force.stuff := strtoint(buf);
    Readln(fichier, buf);
    myplayer.carac.force.actuel := strtoint(buf);
    Readln(fichier, buf);
    myplayer.carac.force.emplacement_libre := strtoint(buf);
    Readln(fichier, buf);
    myplayer.carac.discretion.init := strtoint(buf);
    Readln(fichier, buf);
    myplayer.carac.discretion.stuff := strtoint(buf);
    Readln(fichier, buf);
    myplayer.carac.discretion.actuel := strtoint(buf);
    Readln(fichier, buf);
    myplayer.carac.discretion.emplacement_libre := strtoint(buf);
    Readln(fichier, buf);
    myplayer.carac.degats.init := strtoint(buf);
    Readln(fichier, buf);
    myplayer.carac.degats.stuff := strtoint(buf);
    Readln(fichier, buf);
    myplayer.carac.degats.actuel := strtoint(buf);
    Readln(fichier, buf);
    myplayer.carac.degats.emplacement_libre := strtoint(buf);
    Readln(fichier, buf);
    myplayer.carac.portee.init := strtoint(buf);
    Readln(fichier, buf);
    myplayer.carac.portee.stuff := strtoint(buf);
    Readln(fichier, buf);
    myplayer.carac.portee.actuel := strtoint(buf);
    Readln(fichier, buf);
    myplayer.carac.portee.emplacement_libre := strtoint(buf);
    Readln(fichier, buf);
    myplayer.carac.armure.init := strtoint(buf);
    Readln(fichier, buf);
    myplayer.carac.armure.stuff := strtoint(buf);
    Readln(fichier, buf);
    myplayer.carac.armure.actuel := strtoint(buf);
    Readln(fichier, buf);
    myplayer.carac.armure.emplacement_libre := strtoint(buf);
    Readln(fichier, buf);
    myplayer.carac.vitesse.init := strtoint(buf);
    Readln(fichier, buf);
    myplayer.carac.vitesse.stuff := strtoint(buf);
    Readln(fichier, buf);
    myplayer.carac.vitesse.actuel := strtoint(buf);
    Readln(fichier, buf);
    myplayer.carac.vitesse.emplacement_libre := strtoint(buf);
    Readln(fichier, buf);
    myplayer.carac.taille.init := strtoint(buf);
    Readln(fichier, buf);
    myplayer.carac.taille.stuff := strtoint(buf);
    Readln(fichier, buf);
    myplayer.carac.taille.actuel := strtoint(buf);
    Readln(fichier, buf);
    myplayer.carac.taille.emplacement_libre := strtoint(buf);
    Readln(fichier, buf);



    //maintenant les objts qu'il a sur lui
    len := StrToInt(buf);

    SetLength(myplayer.tab_contenu, len);
    if Len <> 0 then
      for i := 0 to Len - 1 do
        begin
          Readln(fichier, myplayer.tab_contenu[i].nom);
          Readln(fichier, myplayer.tab_contenu[i]._type);
          Readln(fichier, buf);
          myplayer.tab_contenu[i].carac1 := StrToInt(buf);
          Readln(fichier, buf);
          myplayer.tab_contenu[i].carac2 := StrToInt(buf);
          Readln(fichier, buf);
          myplayer.tab_contenu[i].quantite := StrToInt(buf);
          Readln(fichier, buf);
          myplayer.tab_contenu[i].equip := StrToBool(buf);
          Readln(fichier, myplayer.tab_contenu[i].mesh);
          Readln(fichier, myplayer.tab_contenu[i].icone);
          Readln(fichier, buf);
          if buf <> '' then
            myplayer.tab_contenu[i].g_d := buf[1];
        end;
    CloseFile(fichier);
  end;

end.
